home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 3: Developer Tools / Linux Cubed Series 3 - Developer Tools.iso / devel / lang / eiffel / smalleif.97 / se.t / SmallEiffel / bin_c / compile_to_c5.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-05-02  |  43.7 KB  |  1,842 lines
  1. /* ANSI C code generated by SmallEiffel. */
  2. /*
  3. -- SmallEiffel  -- Release (- 0.97)    --      FRANCE
  4. -- Copyright (C), 1994 - Dominique COLNET and Suzanne COLLIN 
  5. -- University Henri Poincare' - Nancy 1 - email colnet@loria.fr 
  6. -- CRIN (Centre de Recherche en Informatique de Nancy)
  7. -- FRANCE 
  8. */
  9. #include "compile_to_c.h"
  10. void rT39disconnect(T39 *C){
  11. int _err=0;
  12. _err=fclose((C)->_input_stream);
  13. C->_path=NULL;
  14. }
  15. T0*oRBC39last_string;
  16. char rT39last_character(T39 *C){
  17. char R='\0';
  18. R=(C)->_last_character_memory;
  19. return R;
  20. }
  21. void rT39connect_to(T39 *C,T0* a1){
  22. /*(IRF3*/((C)->_mode)=((T0 *)ms26);
  23. /*)*/C->_input_stream=rT39fopen(C,a1,(C)->_mode);
  24. /*IF*/{/*AT*/C->_path=a1;
  25. }
  26. /*FI*/}
  27. void rT39skip_separators(T39 *C){
  28. while (!((rT39end_of_input(C))||(!(rT3is_separator(rT39last_character(C)))))) {
  29. rT39read_character(C);
  30. }
  31. }
  32. void * rT39fopen(T39 *C,T0* a1,T0* a2){
  33. void * R=NULL;
  34. rT7extend((T7*)a1,'\0');
  35. rT7extend((T7*)a2,'\0');
  36. R=(T0 *)fopen(((Tstring *)a1)->_storage,((Tstring *)a2)->_storage);
  37. rT7remove_last((T7*)a1,1);
  38. rT7remove_last((T7*)a2,1);
  39. return R;
  40. }
  41. void rT39copy(T39 *C,T0 * a1){
  42. /*IF*//*AF*//*AE*/
  43. memcpy(C,a1,s[C->id]);
  44. /*FI*/}
  45. void rT39read_word(T39 *C){
  46. rT39skip_separators(C);
  47. /*(IRF3*/(((T7*)oRBC39last_string)->_count)=(0);
  48. /*)*/while (!((rT39end_of_input(C))||(rT3is_separator(rT39last_character(C))))) {
  49. rT7extend((T7*)oRBC39last_string,rT39last_character(C));
  50. rT39read_character(C);
  51. }
  52. }
  53. void rT39read_line_in(T39 *C,T0* a1){
  54. /*(IRF3*/(((T7*)a1)->_count)=(0);
  55. /*)*/rT39read_character(C);
  56. while (!((rT39end_of_input(C))||((rT39last_character(C))==('\12')))) {
  57. rT7extend((T7*)a1,rT39last_character(C));
  58. rT39read_character(C);
  59. }
  60. }
  61. void rT39read_line(T39 *C){
  62. rT39read_line_in(C,oRBC39last_string);
  63. }
  64. void rT39read_character(T39 *C){
  65. C->_last_character_memory=fgetc((C)->_input_stream);
  66. }
  67. char rT7_ix64(T7 *C,int a1){
  68. char R='\0';
  69. R=(C->_storage)[a1-1];
  70. return R;
  71. }
  72. int rT7hash_code(T7 *C){
  73. int R=0;
  74. int _i=0;
  75. _i=(C)->_count;
  76. /*IF*/if ((_i)>(5)) {
  77. _i=5;
  78. }
  79. /*FI*/while (!((_i)==(0))) {
  80. R=(R)+(((unsigned char)rT7item(C,_i)));
  81. _i=(_i)-(1);
  82. }
  83. return R;
  84. }
  85. void rT7reverse(T7 *C){
  86. int _i2=0;
  87. int _i1=0;
  88. _i1=1;
  89. _i2=(C)->_count;
  90. while (!((_i1)>=(_i2))) {
  91. rT7swap(C,_i1,_i2);
  92. _i1=(_i1)+(1);
  93. _i2=(_i2)-(1);
  94. }
  95. }
  96. void rT7extend(T7 *C,char a1){
  97. C->_count=((C)->_count)+(1);
  98. /*IF*/if (((C)->_capacity)<((C)->_count)) {
  99. /*IF*/if (((C)->_capacity)==(0)) {
  100. C->_capacity=16;
  101. C->_storage=(char *)malloc((size_t)C->_capacity);
  102. }
  103. else {
  104. C->_capacity=((C)->_capacity)+(16);
  105. C->_storage=(char *)realloc(C->_storage,(size_t)C->_capacity);
  106. }
  107. /*FI*/}
  108. /*FI*/rT7put(C,a1,(C)->_count);
  109. }
  110. int rT7same_as(T7 *C,T0* a1){
  111. int R=0;
  112. int _i=0;
  113. /*IF*/if (((T0 *)a1)==((T0 *)C)) {
  114. R=1;
  115. }
  116. else {
  117. /*IF*/if ((((T7*)a1)->_count)!=((C)->_count)) {
  118. R=0;
  119. }
  120. else {
  121. _i=(C)->_count;
  122. while (!(((_i)==(0))||(!(rT3same_as(rT7item(C,_i),rT7_ix64((T7*)a1,_i)))))) {
  123. _i=(_i)-(1);
  124. }
  125. R=(_i)==(0);
  126. }
  127. /*FI*/}
  128. /*FI*/return R;
  129. }
  130. void rT7to_upper(T7 *C){
  131. int _i=0;
  132. _i=(C)->_count;
  133. while (!((_i)==(0))) {
  134. rT7put(C,rT3to_upper(rT7item(C,_i)),_i);
  135. _i=(_i)-(1);
  136. }
  137. }
  138. char rT7first(T7 *C){
  139. char R='\0';
  140. R=rT7item(C,1);
  141. return R;
  142. }
  143. void rT7remove_between(T7 *C,int a1,int a2){
  144. int _i=0;
  145. _i=a2;
  146. while (!((_i)>=((C)->_count))) {
  147. rT7put(C,rT7item(C,(_i)+(1)),((a1)+(_i))-(a2));
  148. _i=(_i)+(1);
  149. }
  150. C->_count=((C)->_count)-(((a2)-(a1))+(1));
  151. }
  152. void rT7remove_first(T7 *C,int a1){
  153. /*IF*/if ((a1)>(0)) {
  154. rT7remove_between(C,1,a1);
  155. }
  156. /*FI*/}
  157. void rT7remove_last(T7 *C,int a1){
  158. C->_count=((C)->_count)-(a1);
  159. }
  160. int rT7has_prefix(T7 *C,T0* a1){
  161. int R=0;
  162. int _i=0;
  163. /*IF*/if ((((T7*)a1)->_count)<=((C)->_count)) {
  164. _i=((T7*)a1)->_count;
  165. while (!(((_i)==(0))||((rT7item(C,_i))!=(rT7item((T7*)a1,_i))))) {
  166. _i=(_i)-(1);
  167. }
  168. R=(_i)==(0);
  169. }
  170. /*FI*/return R;
  171. }
  172. int rT7has_suffix(T7 *C,T0* a1){
  173. int R=0;
  174. int _i2=0;
  175. int _i1=0;
  176. /*IF*/if ((((T7*)a1)->_count)<=((C)->_count)) {
  177. _i1=(((C)->_count)-(((T7*)a1)->_count))+(1);
  178. _i2=1;
  179. while (!((((_i1)>((C)->_count))||((_i2)>(((T7*)a1)->_count)))||((rT7item(C,_i1))!=(rT7item((T7*)a1,_i2))))) {
  180. _i1=(_i1)+(1);
  181. _i2=(_i2)+(1);
  182. }
  183. R=(_i1)>((C)->_count);
  184. }
  185. /*FI*/return R;
  186. }
  187. void rT7precede(T7 *C,char a1){
  188. int _i=0;
  189. rT7extend(C,'\40');
  190. _i=(C)->_count;
  191. while (!((_i)==(1))) {
  192. rT7put(C,rT7item(C,(_i)-(1)),_i);
  193. _i=(_i)-(1);
  194. }
  195. rT7put(C,a1,1);
  196. }
  197. int rT7empty(T7 *C){
  198. int R=0;
  199. R=((C)->_count)==(0);
  200. return R;
  201. }
  202. char rT7item(T7 *C,int a1){
  203. char R='\0';
  204. R=(C->_storage)[a1-1];
  205. return R;
  206. }
  207. T0* rT7substring(T7 *C,int a1,int a2){
  208. T0* R=NULL;
  209. int _i=0;
  210. {T7 *n=((T7*)new(7));
  211. rT7make(n,((a2)-(a1))+(1));
  212. R=(T0 *)n;}
  213. _i=a1;
  214. while (!((_i)>(a2))) {
  215. rT7extend((T7*)R,rT7item(C,_i));
  216. _i=(_i)+(1);
  217. }
  218. return R;
  219. }
  220. int rT7is_equal(T7 *C,T0* a1){
  221. int R=0;
  222. int _i=0;
  223. /*IF*/if (((T0 *)C)==((T0 *)a1)) {
  224. R=1;
  225. }
  226. else {
  227. _i=(C)->_count;
  228. R=(_i)==(((T7*)a1)->_count);
  229. while (!((!(R))||((_i)==(0)))) {
  230. R=(rT7item(C,_i))==(rT7item((T7*)a1,_i));
  231. _i=(_i)-(1);
  232. }
  233. }
  234. /*FI*/return R;
  235. }
  236. void rT7append(T7 *C,T0* a1){
  237. int _i=0;
  238. _i=1;
  239. while (!((_i)>(((T7*)a1)->_count))) {
  240. rT7extend(C,rT7_ix64((T7*)a1,_i));
  241. _i=(_i)+(1);
  242. }
  243. }
  244. char rT7last(T7 *C){
  245. char R='\0';
  246. R=rT7item(C,(C)->_count);
  247. return R;
  248. }
  249. int rT7to_integer(T7 *C){
  250. int R=0;
  251. int _minus=0;
  252. char _cc='\0';
  253. int _state=0;
  254. int _i=0;
  255. _i=1;
  256. while (!(((_i)>((C)->_count))||((_state)==(4)))) {
  257. _cc=rT7item(C,_i);
  258. {int iv1=_state;
  259. if (0 == iv1) goto l31;
  260. goto l32;
  261.  l31: ;
  262. /*IF*/if (rT3is_separator(_cc)) {
  263. }
  264.  else if ((_cc)==('\53')) {
  265. _state=1;
  266. }
  267.  else if ((_cc)==('\55')) {
  268. _minus=1;
  269. _state=1;
  270. }
  271.  else if (rT3is_digit(_cc)) {
  272. R=rT3value(_cc);
  273. _state=2;
  274. }
  275. else {
  276. _state=4;
  277. }
  278. /*FI*/goto l30;
  279.  l32: ;
  280. if (1 == iv1) goto l33;
  281. goto l34;
  282.  l33: ;
  283. /*IF*/if (rT3is_separator(_cc)) {
  284. }
  285.  else if (rT3is_digit(_cc)) {
  286. R=rT3value(_cc);
  287. _state=2;
  288. }
  289. else {
  290. _state=4;
  291. }
  292. /*FI*/goto l30;
  293.  l34: ;
  294. if (2 == iv1) goto l35;
  295. goto l36;
  296.  l35: ;
  297. /*IF*/if (rT3is_digit(_cc)) {
  298. R=((R)*(10))+(rT3value(_cc));
  299. }
  300.  else if (rT3is_separator(_cc)) {
  301. _state=3;
  302. }
  303. else {
  304. _state=4;
  305. }
  306. /*FI*/goto l30;
  307.  l36: ;
  308. /*IF*/if (rT3is_separator(_cc)) {
  309. }
  310. else {
  311. _state=4;
  312. }
  313. /*FI*/ l30: ;
  314. }
  315. _i=(_i)+(1);
  316. }
  317. /*IF*/if ((_state)==(4)) {
  318. rT33put_string((T33*)oRBC1std_error,(T0 *)ms833);
  319. rT33put_string((T33*)oRBC1std_error,(T0 *)C);
  320. rT33put_string((T33*)oRBC1std_error,(T0 *)ms834);
  321. }
  322.  else if (_minus) {
  323. R=-(R);
  324. }
  325. /*FI*/return R;
  326. }
  327. void rT7put(T7 *C,char a1,int a2){
  328. (C->_storage)[a2-1]=a1;
  329. }
  330. void rT7swap(T7 *C,int a1,int a2){
  331. char _tmp='\0';
  332. _tmp=rT7item(C,a1);
  333. rT7put(C,rT7item(C,a2),a1);
  334. rT7put(C,_tmp,a2);
  335. }
  336. void rT7copy(T7 *C,T0* a1){
  337. int _i=0;
  338. _i=((T7*)a1)->_count;
  339. C->_count=_i;
  340. /*IF*/if ((_i)>(0)) {
  341. /*IF*/if (((C)->_capacity)<(_i)) {
  342. /*IF*/if (((C)->_capacity)==(0)) {
  343. C->_storage=(char *)malloc((size_t)_i);
  344. }
  345. else {
  346. C->_storage=(char *)realloc(C->_storage,(size_t)_i);
  347. }
  348. /*FI*/C->_capacity=_i;
  349. }
  350. /*FI*/while (!((_i)==(0))) {
  351. rT7put(C,rT7item((T7*)a1,_i),_i);
  352. _i=(_i)-(1);
  353. }
  354. }
  355. /*FI*/}
  356. void rT7prepend(T7 *C,T0* a1){
  357. int _old_count=0;
  358. int _i=0;
  359. _old_count=(C)->_count;
  360. _i=((T7*)a1)->_count;
  361. while (!((_i)==(0))) {
  362. rT7extend(C,'\40');
  363. _i=(_i)-(1);
  364. }
  365. _i=(C)->_count;
  366. while (!((_old_count)==(0))) {
  367. rT7put(C,rT7item(C,_old_count),_i);
  368. _i=(_i)-(1);
  369. _old_count=(_old_count)-(1);
  370. }
  371. _i=((T7*)a1)->_count;
  372. while (!((_i)==(0))) {
  373. rT7put(C,rT7_ix64((T7*)a1,_i),_i);
  374. _i=(_i)-(1);
  375. }
  376. }
  377. void rT7to_lower(T7 *C){
  378. int _i=0;
  379. _i=(C)->_count;
  380. while (!((_i)==(0))) {
  381. rT7put(C,rT3to_lower(rT7item(C,_i)),_i);
  382. _i=(_i)-(1);
  383. }
  384. }
  385. void rT7make(T7 *C,int a1){
  386. C->_count=0;
  387. /*IF*/if ((a1)>(0)) {
  388. /*IF*/if (((C)->_capacity)<(a1)) {
  389. /*IF*/if (((C)->_capacity)==(0)) {
  390. C->_storage=(char *)malloc((size_t)a1);
  391. }
  392. else {
  393. C->_storage=(char *)realloc(C->_storage,(size_t)a1);
  394. }
  395. /*FI*/C->_capacity=a1;
  396. }
  397. /*FI*/}
  398. /*FI*/}
  399. T0 * rT233current_type(T233 *C){
  400. T0 * R=NULL;
  401. R=rT226current_type((T226*)(C)->_e_when);
  402. return R;
  403. }
  404. T0 * rT233to_runnable_character(T233 *C,T0 * a1){
  405. T0 * R=NULL;
  406. T0 * _v=NULL;
  407. /*IF*/if (!((C)->_e_when)) {
  408. C->_e_when=a1;
  409. _v=XrT68to_runnable((C)->_lower,rT233current_type(C));
  410. /*IF*/if ((((int)_v))&&(XrT58is_character(XrT68result_type(_v)))) {
  411. C->_lower=_v;
  412. C->_lower_value=XrT68to_integer((C)->_lower);
  413. }
  414. else {
  415. rT233error(XrT68start_position((C)->_lower),(T0 *)ms1350);
  416. }
  417. /*FI*/_v=XrT68to_runnable((C)->_upper,rT233current_type(C));
  418. /*IF*/if ((((int)_v))&&(XrT58is_character(XrT68result_type(_v)))) {
  419. C->_upper=_v;
  420. C->_upper_value=XrT68to_integer((C)->_upper);
  421. }
  422. else {
  423. rT233error(XrT68start_position((C)->_upper),(T0 *)ms1351);
  424. }
  425. /*FI*/rT226add_when_item_2((T226*)(C)->_e_when,(T0 *)C);
  426. R=(T0 *)C;
  427. }
  428. else {
  429. {T233 *n=((T233*)new(233));
  430. rT233make(n,(C)->_lower,(C)->_upper);
  431. R=(T0 *)n;}
  432. R=rT233to_runnable_character((T233*)R,a1);
  433. }
  434. /*FI*/return R;
  435. }
  436. T0 * rT233to_runnable_integer(T233 *C,T0 * a1){
  437. T0 * R=NULL;
  438. T0 * _v=NULL;
  439. /*IF*/if (!((C)->_e_when)) {
  440. C->_e_when=a1;
  441. _v=XrT68to_runnable((C)->_lower,rT233current_type(C));
  442. /*IF*/if ((((int)_v))&&(XrT58is_integer(XrT68result_type(_v)))) {
  443. C->_lower=_v;
  444. C->_lower_value=XrT68to_integer((C)->_lower);
  445. }
  446. else {
  447. rT233error(XrT68start_position((C)->_lower),(T0 *)ms1346);
  448. }
  449. /*FI*/_v=XrT68to_runnable((C)->_upper,rT233current_type(C));
  450. /*IF*/if ((((int)_v))&&(XrT58is_integer(XrT68result_type(_v)))) {
  451. C->_upper=_v;
  452. C->_upper_value=XrT68to_integer((C)->_upper);
  453. }
  454. else {
  455. rT233error(XrT68start_position((C)->_upper),(T0 *)ms1347);
  456. }
  457. /*FI*/rT226add_when_item_2((T226*)(C)->_e_when,(T0 *)C);
  458. R=(T0 *)C;
  459. }
  460. else {
  461. {T233 *n=((T233*)new(233));
  462. rT233make(n,(C)->_lower,(C)->_upper);
  463. R=(T0 *)n;}
  464. R=rT233to_runnable_integer((T233*)R,a1);
  465. }
  466. /*FI*/return R;
  467. }
  468. void rT233error(/*C*/T0 * a1,T0* a2){
  469. /*UT*/(T45*)oRBC27eh;
  470. rT45add_position(a1);
  471. rT45error((T45*)oRBC27eh,a2);
  472. }
  473. T0 * rT233start_position(T233 *C){
  474. T0 * R=NULL;
  475. R=XrT68start_position((C)->_lower);
  476. return R;
  477. }
  478. void rT233copy(T233 *C,T0 * a1){
  479. /*IF*//*AF*//*AE*/
  480. memcpy(C,a1,s[C->id]);
  481. /*FI*/}
  482. void rT233make(T233 *C,T0 * a1,T0 * a2){
  483. C->_lower=a1;
  484. C->_upper=a2;
  485. }
  486. T0 * rT231current_type(T231 *C){
  487. T0 * R=NULL;
  488. R=rT225current_type((T225*)(C)->_e_inspect);
  489. return R;
  490. }
  491. T0 * rT231to_runnable_integer(T231 *C,T0 * a1){
  492. T0 * R=NULL;
  493. T0 * _e_when=NULL;
  494. int _ne=0;
  495. int _i=0;
  496. /*IF*/if (!((C)->_e_inspect)) {
  497. _ne=/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/;
  498. C->_e_inspect=a1;
  499. _i=1;
  500. while (!(((_i)>(((T232*)(C)->_list)->_upper))||(((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)-(_ne))>(0)))) {
  501. _e_when=rT226to_runnable_integer((T226*)rT232item((T232*)(C)->_list,_i),(T0 *)C);
  502. /*IF*/if (!(_e_when)) {
  503. rT231error(rT231start_position(C),(T0 *)ms1232);
  504. }
  505. else {
  506. rT232put((T232*)(C)->_list,_e_when,_i);
  507. }
  508. /*FI*/_i=(_i)+(1);
  509. }
  510. R=(T0 *)C;
  511. }
  512. else {
  513. {T231 *n=((T231*)new(231));
  514. rT231from_when_list(n,(T0 *)C);
  515. R=(T0 *)n;}
  516. R=rT231to_runnable_integer((T231*)R,a1);
  517. }
  518. /*FI*/return R;
  519. }
  520. T0 * rT231to_runnable_character(T231 *C,T0 * a1){
  521. T0 * R=NULL;
  522. T0 * _e_when=NULL;
  523. int _ne=0;
  524. int _i=0;
  525. /*IF*/if (!((C)->_e_inspect)) {
  526. _ne=/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/;
  527. C->_e_inspect=a1;
  528. _i=1;
  529. while (!(((_i)>(((T232*)(C)->_list)->_upper))||(((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)-(_ne))>(0)))) {
  530. _e_when=rT226to_runnable_character((T226*)rT232item((T232*)(C)->_list,_i),(T0 *)C);
  531. /*IF*/if (!(_e_when)) {
  532. rT231error(rT231start_position(C),(T0 *)ms1232);
  533. }
  534. else {
  535. rT232put((T232*)(C)->_list,_e_when,_i);
  536. }
  537. /*FI*/_i=(_i)+(1);
  538. }
  539. R=(T0 *)C;
  540. }
  541. else {
  542. {T231 *n=((T231*)new(231));
  543. rT231from_when_list(n,(T0 *)C);
  544. R=(T0 *)n;}
  545. R=rT231to_runnable_character((T231*)R,a1);
  546. }
  547. /*FI*/return R;
  548. }
  549. void rT231error(/*C*/T0 * a1,T0* a2){
  550. /*UT*/(T45*)oRBC27eh;
  551. rT45add_position(a1);
  552. rT45error((T45*)oRBC27eh,a2);
  553. }
  554. T0 * rT231start_position(T231 *C){
  555. T0 * R=NULL;
  556. R=((T226*)rT232first((T232*)(C)->_list))->_start_position;
  557. return R;
  558. }
  559. int rT231use_current(T231 *C){
  560. int R=0;
  561. int _i=0;
  562. /*IF*/if (((int)(C)->_list)) {
  563. _i=1;
  564. while (!(((_i)>(((T232*)(C)->_list)->_upper))||(R))) {
  565. R=rT226use_current((T226*)rT232item((T232*)(C)->_list,_i));
  566. _i=(_i)+(1);
  567. }
  568. }
  569. /*FI*/return R;
  570. }
  571. T0* rT231clone(T231 *C,T0* a1){
  572. T0* R=NULL;
  573. /*IF*/if (((int)a1)) {
  574. R=(T0 *)new(a1->id);
  575. AF_1
  576. XrT28copy(R,a1);
  577. AF_0
  578. }
  579. /*FI*/return R;
  580. }
  581. void rT231from_when_list(T231 *C,T0 * a1){
  582. T0 * _e_when=NULL;
  583. int _i=0;
  584. C->_list=rT231clone(C,((T231*)a1)->_list);
  585. _i=1;
  586. while (!((_i)>(((T232*)(C)->_list)->_upper))) {
  587. {T226 *n=((T226*)new(226));
  588. rT226from_e_when(n,rT232item((T232*)(C)->_list,_i));
  589. _e_when=(T0 *)n;}
  590. rT232put((T232*)(C)->_list,_e_when,_i);
  591. _i=(_i)+(1);
  592. }
  593. }
  594. void rT231add_last(T231 *C,T0 * a1){
  595. rT232add_last((T232*)(C)->_list,a1);
  596. }
  597. void rT231compile_to_c(T231 *C,int a1){
  598. int _i=0;
  599. /*IF*/if (((int)(C)->_list)) {
  600. _i=1;
  601. while (!((_i)>(((T232*)(C)->_list)->_upper))) {
  602. rT226compile_to_c((T226*)rT232item((T232*)(C)->_list,_i),a1);
  603. _i=(_i)+(1);
  604. }
  605. }
  606. /*FI*/}
  607. void rT231copy(T231 *C,T0 * a1){
  608. /*IF*//*AF*//*AE*/
  609. memcpy(C,a1,s[C->id]);
  610. /*FI*/}
  611. int rT231includes_integer(T231 *C,int a1){
  612. int R=0;
  613. int _i=0;
  614. _i=1;
  615. while (!((R)||((_i)>(((T232*)(C)->_list)->_upper)))) {
  616. R=rT226includes_integer((T226*)rT232item((T232*)(C)->_list,_i),a1);
  617. _i=(_i)+(1);
  618. }
  619. return R;
  620. }
  621. T0 * rT227current_type(T227 *C){
  622. T0 * R=NULL;
  623. R=rT226current_type((T226*)(C)->_e_when);
  624. return R;
  625. }
  626. T0 * rT227to_runnable_character(T227 *C,T0 * a1){
  627. T0 * R=NULL;
  628. T0 * _e=NULL;
  629. /*IF*/if (!((C)->_e_when)) {
  630. C->_e_when=a1;
  631. _e=XrT68to_runnable((C)->_expression,rT227current_type(C));
  632. /*IF*/if ((((int)_e))&&(XrT58is_character(XrT68result_type(_e)))) {
  633. C->_expression=_e;
  634. C->_expression_value=XrT68to_integer((C)->_expression);
  635. rT226add_when_item_1((T226*)(C)->_e_when,(T0 *)C);
  636. }
  637. else {
  638. rT227error(XrT68start_position((C)->_expression),(T0 *)ms1349);
  639. }
  640. /*FI*/R=(T0 *)C;
  641. }
  642. else {
  643. {T227 *n=((T227*)new(227));
  644. /*(IRF3*/((n)->_expression)=((C)->_expression);
  645. /*)*/R=(T0 *)n;}
  646. R=rT227to_runnable_character((T227*)R,a1);
  647. }
  648. /*FI*/return R;
  649. }
  650. T0 * rT227to_runnable_integer(T227 *C,T0 * a1){
  651. T0 * R=NULL;
  652. T0 * _e=NULL;
  653. /*IF*/if (!((C)->_e_when)) {
  654. C->_e_when=a1;
  655. _e=XrT68to_runnable((C)->_expression,rT227current_type(C));
  656. /*IF*/if ((((int)_e))&&(XrT58is_integer(XrT68result_type(_e)))) {
  657. C->_expression=_e;
  658. C->_expression_value=XrT68to_integer((C)->_expression);
  659. rT226add_when_item_1((T226*)(C)->_e_when,(T0 *)C);
  660. }
  661. else {
  662. rT227error(XrT68start_position((C)->_expression),(T0 *)ms1345);
  663. }
  664. /*FI*/R=(T0 *)C;
  665. }
  666. else {
  667. {T227 *n=((T227*)new(227));
  668. /*(IRF3*/((n)->_expression)=((C)->_expression);
  669. /*)*/R=(T0 *)n;}
  670. R=rT227to_runnable_integer((T227*)R,a1);
  671. }
  672. /*FI*/return R;
  673. }
  674. void rT227error(/*C*/T0 * a1,T0* a2){
  675. /*UT*/(T45*)oRBC27eh;
  676. rT45add_position(a1);
  677. rT45error((T45*)oRBC27eh,a2);
  678. }
  679. T0 * rT227start_position(T227 *C){
  680. T0 * R=NULL;
  681. R=XrT68start_position((C)->_expression);
  682. return R;
  683. }
  684. void rT227copy(T227 *C,T0 * a1){
  685. /*IF*//*AF*//*AE*/
  686. memcpy(C,a1,s[C->id]);
  687. /*FI*/}
  688. int rT172static_value(T172 *C){
  689. int R=0;
  690. R=(C)->_static_value_mem;
  691. return R;
  692. }
  693. T0 * rT172to_runnable(T172 *C,T0 * a1){
  694. T0 * R=NULL;
  695. /*IF*/if (!((C)->_current_type)) {
  696. C->_current_type=a1;
  697. R=(T0 *)C;
  698. }
  699. else {
  700. R=rT172clone(C,(T0 *)C);
  701. /*(IRF3*/(((T172*)R)->_current_type)=(a1);
  702. /*)*/}
  703. /*FI*/return R;
  704. }
  705. void rT172error(/*C*/T0 * a1,T0* a2){
  706. /*UT*/(T45*)oRBC27eh;
  707. rT45add_position(a1);
  708. rT45error((T45*)oRBC27eh,a2);
  709. }
  710. T0 * rT172add_comment(T172 *C,T0 * a1){
  711. T0 * R=NULL;
  712. /*IF*/if ((!(a1))||((rT59count((T59*)a1))==(0))) {
  713. R=(T0 *)C;
  714. }
  715. else {
  716. {T220 *n=((T220*)new(220));
  717. rT220make(n,(T0 *)C,a1);
  718. R=(T0 *)n;}}
  719. /*FI*/return R;
  720. }
  721. int ofBC172result_type=0;
  722. T0*oRBC172result_type;
  723. T0 * rT172result_type(/*C*/void){
  724. T0 * R=NULL;
  725. if (ofBC172result_type==0){
  726. ofBC172result_type=1;
  727. {T112 *n=((T112*)new(112));
  728. rT112make(n,NULL);
  729. R=(T0 *)n;}
  730. oRBC172result_type=R;}
  731. return oRBC172result_type;}
  732. T0* rT172clone(T172 *C,T0* a1){
  733. T0* R=NULL;
  734. /*IF*/if (((int)a1)) {
  735. R=(T0 *)new(a1->id);
  736. AF_1
  737. XrT28copy(R,a1);
  738. AF_0
  739. }
  740. /*FI*/return R;
  741. }
  742. T0* rT172to_key(T172 *C){
  743. T0* R=NULL;
  744. R=(C)->_to_string;
  745. return R;
  746. }
  747. int rT172to_integer(T172 *C){
  748. int R=0;
  749. rT172error((C)->_start_position,(T0 *)ms175);
  750. return R;
  751. }
  752. T0 * rT172written_in(T172 *C){
  753. T0 * R=NULL;
  754. T0 * _sp=NULL;
  755. _sp=(C)->_start_position;
  756. /*IF*/if (((int)_sp)) {
  757. R=((T46*)_sp)->_base_class_name;
  758. }
  759. /*FI*/return R;
  760. }
  761. void rT172copy(T172 *C,T0 * a1){
  762. /*IF*//*AF*//*AE*/
  763. memcpy(C,a1,s[C->id]);
  764. /*FI*/}
  765. int rT172is_a(T172 *C,T0 * a1){
  766. int R=0;
  767. R=XrT58is_a(rT112run_type((T112*)rT172result_type()),XrT58run_type(XrT68result_type(a1)));
  768. /*IF*/if (!(R)) {
  769. /*UT*/(T45*)oRBC27eh;
  770. rT45add_position((C)->_start_position);
  771. rT172error(XrT68start_position(a1),(T0 *)ms1261);
  772. }
  773. /*FI*/return R;
  774. }
  775. void rT172make(T172 *C,T0 * a1){
  776. C->_start_position=a1;
  777. C->_to_string=(T0 *)ms295;
  778. }
  779. T0 * rT180current_type(T180 *C){
  780. T0 * R=NULL;
  781. /*IF*/if (((int)(C)->_run_compound)) {
  782. R=((T140*)(C)->_run_compound)->_current_type;
  783. }
  784. /*FI*/return R;
  785. }
  786. void rT180to_runnable_0(T180 *C,T0 * a1){
  787. T0 * _tt=NULL;
  788. T0 * _t=NULL;
  789. C->_run_compound=a1;
  790. _t=XrT68to_runnable((C)->_target,rT180current_type(C));
  791. /*IF*/if (!(_t)) {
  792. rT180error(XrT68start_position((C)->_target),(T0 *)ms1218);
  793. }
  794. else {
  795. C->_target=_t;
  796. _tt=XrT58run_type(XrT68result_type((C)->_target));
  797. C->_run_feature=rT260get_rf((T260*)XrT58run_class(_tt),(C)->_target,(C)->_procedure_name);
  798. }
  799. /*FI*//*IF*/if (((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)==(0))&&(((int)XrT261result_type((C)->_run_feature)))) {
  800. /*UT*/(T45*)oRBC27eh;
  801. rT45add_position(XrT261start_position((C)->_run_feature));
  802. /*UT*/(T45*)oRBC27eh;
  803. rT45append((T0 *)ms1219);
  804. rT180error(XrT67start_position((C)->_procedure_name),(T0 *)ms1220);
  805. }
  806. /*FI*//*IF*/if ((((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)==(0))&&(!(XrT68is_current((C)->_target))))&&(!(XrT261is_exported_in((C)->_run_feature,XrT68written_in((C)->_target))))) {
  807. /*UT*/(T45*)oRBC27eh;
  808. rT45add_position(XrT261start_position((C)->_run_feature));
  809. /*UT*/(T45*)oRBC27eh;
  810. rT45append((T0 *)ms1221);
  811. /*UT*/(T45*)oRBC27eh;
  812. rT45append(XrT67to_string((C)->_procedure_name));
  813. rT180error(XrT67start_position((C)->_procedure_name),(T0 *)ms1222);
  814. }
  815. /*FI*/}
  816. T0 * rT180to_runnable(T180 *C,T0 * a1){
  817. T0 * R=NULL;
  818. T0 * _a=NULL;
  819. /*IF*/if (!((C)->_run_compound)) {
  820. rT180to_runnable_0(C,a1);
  821. /*IF*/if ((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)==(0)) {
  822. _a=rT170to_runnable((T170*)(C)->_arguments,rT180current_type(C));
  823. /*IF*/if (!(_a)) {
  824. rT180error(rT170start_position((T170*)(C)->_arguments),(T0 *)ms1225);
  825. }
  826. else {
  827. C->_arguments=_a;
  828. }
  829. /*FI*/}
  830. /*FI*//*IF*/if ((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)==(0)) {
  831. rT170match_with((T170*)(C)->_arguments,(C)->_run_feature);
  832. }
  833. /*FI*//*IF*/if ((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)==(0)) {
  834. R=(T0 *)C;
  835. }
  836. /*FI*/}
  837. else {
  838. {T180 *n=((T180*)new(180));
  839. rT180make(n,(C)->_target,(C)->_procedure_name,(C)->_arguments);
  840. R=(T0 *)n;}
  841. R=rT180to_runnable((T180*)R,a1);
  842. }
  843. /*FI*/return R;
  844. }
  845. void rT180error(/*C*/T0 * a1,T0* a2){
  846. /*UT*/(T45*)oRBC27eh;
  847. rT45add_position(a1);
  848. rT45error((T45*)oRBC27eh,a2);
  849. }
  850. T0 * rT180add_comment(T180 *C,T0 * a1){
  851. T0 * R=NULL;
  852. /*IF*/if ((!(a1))||((rT59count((T59*)a1))==(0))) {
  853. R=(T0 *)C;
  854. }
  855. /*AF*/else {
  856. {T216 *n=((T216*)new(216));
  857. rT216make(n,(T0 *)C,a1);
  858. R=(T0 *)n;}}
  859. /*FI*/return R;
  860. }
  861. T0 * rT180start_position(T180 *C){
  862. T0 * R=NULL;
  863. R=XrT68start_position((C)->_target);
  864. /*IF*/if (!(R)) {
  865. R=XrT67start_position((C)->_procedure_name);
  866. }
  867. /*FI*/return R;
  868. }
  869. int rT180use_current(T180 *C){
  870. int R=0;
  871. /*IF*/if ((rT180arg_count(C))>(0)) {
  872. R=rT170use_current((T170*)(C)->_arguments);
  873. }
  874. /*FI*//*IF*/if (R) {
  875. }
  876.  else if (XrT68is_current((C)->_target)) {
  877. R=XrT261use_current((C)->_run_feature);
  878. }
  879. else {
  880. R=XrT68use_current((C)->_target);
  881. }
  882. /*FI*/return R;
  883. }
  884. void rT180compile_to_c(T180 *C){
  885. T0 * _dyn_rf=NULL;
  886. T0 * _tt=NULL;
  887. T0* _r=NULL;
  888. rT40rs_push_position((T40*)oRBC27cpp,'3',rT180start_position(C));
  889. _tt=XrT58run_type(XrT68result_type((C)->_target));
  890. /*IF*/if (((XrT58is_expanded(_tt))||(XrT68is_current((C)->_target)))||(XrT68is_manifest_string((C)->_target))) {
  891. rT40push_direct((T40*)oRBC27cpp,(C)->_run_feature,(C)->_target,(C)->_arguments);
  892. XrT261mapping_c((C)->_run_feature);
  893. rT40pop((T40*)oRBC27cpp);
  894. }
  895. else {
  896. _r=((T260*)XrT58run_class(_tt))->_running;
  897. /*IF*/if (!(_r)) {
  898. rT40push_void((T40*)oRBC27cpp,(C)->_run_feature,(C)->_target,(C)->_arguments);
  899. XrT261mapping_c((C)->_run_feature);
  900. rT40pop((T40*)oRBC27cpp);
  901. }
  902.  else if ((rT263count((T263*)_r))==(1)) {
  903. _dyn_rf=rT180dynamic(rT263first((T263*)_r),(C)->_run_feature);
  904. rT40push_check((T40*)oRBC27cpp,_dyn_rf,(C)->_target,(C)->_arguments);
  905. XrT261mapping_c(_dyn_rf);
  906. rT40pop((T40*)oRBC27cpp);
  907. }
  908. else {
  909. rT40use_switch((T40*)oRBC27cpp,(C)->_run_feature,_r,(C)->_target,(C)->_arguments);
  910. }
  911. /*FI*/}
  912. /*FI*/rT40rs_pop_position((T40*)oRBC27cpp);
  913. }
  914. T0 * rT180dynamic(/*C*/T0 * a1,T0 * a2){
  915. T0 * R=NULL;
  916. T0 * _static=NULL;
  917. T0 * _sta_name=NULL;
  918. T0 * _dyn_name=NULL;
  919. _static=XrT261current_type(a2);
  920. _sta_name=XrT261name(a2);
  921. _dyn_name=rT50name_of((T50*)rT260base_class((T260*)a1),XrT58base_class(_static),_sta_name);
  922. R=rT260get_feature((T260*)a1,_dyn_name);
  923. return R;
  924. }
  925. void rT180copy(T180 *C,T0 * a1){
  926. /*IF*//*AF*//*AE*/
  927. memcpy(C,a1,s[C->id]);
  928. /*FI*/}
  929. int rT180arg_count(T180 *C){
  930. int R=0;
  931. R=rT170count((T170*)(C)->_arguments);
  932. return R;
  933. }
  934. void rT180make(T180 *C,T0 * a1,T0 * a2,T0 * a3){
  935. C->_target=a1;
  936. C->_procedure_name=a2;
  937. C->_arguments=a3;
  938. }
  939. T0 * rT179current_type(T179 *C){
  940. T0 * R=NULL;
  941. /*IF*/if (((int)(C)->_run_compound)) {
  942. R=((T140*)(C)->_run_compound)->_current_type;
  943. }
  944. /*FI*/return R;
  945. }
  946. void rT179to_runnable_0(T179 *C,T0 * a1){
  947. T0 * _tt=NULL;
  948. T0 * _t=NULL;
  949. C->_run_compound=a1;
  950. _t=XrT68to_runnable((C)->_target,rT179current_type(C));
  951. /*IF*/if (!(_t)) {
  952. rT179error(XrT68start_position((C)->_target),(T0 *)ms1218);
  953. }
  954. else {
  955. C->_target=_t;
  956. _tt=XrT58run_type(XrT68result_type((C)->_target));
  957. C->_run_feature=rT260get_rf((T260*)XrT58run_class(_tt),(C)->_target,(C)->_procedure_name);
  958. }
  959. /*FI*//*IF*/if (((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)==(0))&&(((int)XrT261result_type((C)->_run_feature)))) {
  960. /*UT*/(T45*)oRBC27eh;
  961. rT45add_position(XrT261start_position((C)->_run_feature));
  962. /*UT*/(T45*)oRBC27eh;
  963. rT45append((T0 *)ms1219);
  964. rT179error(XrT67start_position((C)->_procedure_name),(T0 *)ms1220);
  965. }
  966. /*FI*//*IF*/if ((((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)==(0))&&(!(XrT68is_current((C)->_target))))&&(!(XrT261is_exported_in((C)->_run_feature,XrT68written_in((C)->_target))))) {
  967. /*UT*/(T45*)oRBC27eh;
  968. rT45add_position(XrT261start_position((C)->_run_feature));
  969. /*UT*/(T45*)oRBC27eh;
  970. rT45append((T0 *)ms1221);
  971. /*UT*/(T45*)oRBC27eh;
  972. rT45append(XrT67to_string((C)->_procedure_name));
  973. rT179error(XrT67start_position((C)->_procedure_name),(T0 *)ms1222);
  974. }
  975. /*FI*/}
  976. T0 * rT179to_runnable(T179 *C,T0 * a1){
  977. T0 * R=NULL;
  978. T0 * _a=NULL;
  979. /*IF*/if (!((C)->_run_compound)) {
  980. rT179to_runnable_0(C,a1);
  981. /*IF*/if ((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)==(0)) {
  982. _a=rT170to_runnable((T170*)(C)->_arguments,rT179current_type(C));
  983. /*IF*/if (!(_a)) {
  984. rT179error(XrT68start_position(rT179arg1(C)),(T0 *)ms1224);
  985. }
  986. else {
  987. C->_arguments=_a;
  988. }
  989. /*FI*/}
  990. /*FI*//*IF*/if ((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)==(0)) {
  991. rT170match_with((T170*)(C)->_arguments,(C)->_run_feature);
  992. }
  993. /*FI*//*IF*/if ((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)==(0)) {
  994. R=(T0 *)C;
  995. }
  996. /*FI*/}
  997. else {
  998. {T179 *n=((T179*)new(179));
  999. rT179make(n,(C)->_target,(C)->_procedure_name,(C)->_arguments);
  1000. R=(T0 *)n;}
  1001. R=rT179to_runnable((T179*)R,a1);
  1002. }
  1003. /*FI*/return R;
  1004. }
  1005. void rT179error(/*C*/T0 * a1,T0* a2){
  1006. /*UT*/(T45*)oRBC27eh;
  1007. rT45add_position(a1);
  1008. rT45error((T45*)oRBC27eh,a2);
  1009. }
  1010. T0 * rT179add_comment(T179 *C,T0 * a1){
  1011. T0 * R=NULL;
  1012. /*IF*/if ((!(a1))||((rT59count((T59*)a1))==(0))) {
  1013. R=(T0 *)C;
  1014. }
  1015. /*AF*/else {
  1016. {T216 *n=((T216*)new(216));
  1017. rT216make(n,(T0 *)C,a1);
  1018. R=(T0 *)n;}}
  1019. /*FI*/return R;
  1020. }
  1021. T0 * rT179arg1(T179 *C){
  1022. T0 * R=NULL;
  1023. R=rT170first((T170*)(C)->_arguments);
  1024. return R;
  1025. }
  1026. T0 * rT179start_position(T179 *C){
  1027. T0 * R=NULL;
  1028. R=XrT68start_position((C)->_target);
  1029. /*IF*/if (!(R)) {
  1030. R=XrT67start_position((C)->_procedure_name);
  1031. }
  1032. /*FI*/return R;
  1033. }
  1034. int rT179use_current(T179 *C){
  1035. int R=0;
  1036. /*IF*/{/*AT*/R=rT170use_current((T170*)(C)->_arguments);
  1037. }
  1038. /*FI*//*IF*/if (R) {
  1039. }
  1040.  else if (XrT68is_current((C)->_target)) {
  1041. R=XrT261use_current((C)->_run_feature);
  1042. }
  1043. else {
  1044. R=XrT68use_current((C)->_target);
  1045. }
  1046. /*FI*/return R;
  1047. }
  1048. void rT179compile_to_c(T179 *C){
  1049. T0 * _dyn_rf=NULL;
  1050. T0 * _tt=NULL;
  1051. T0* _r=NULL;
  1052. rT40rs_push_position((T40*)oRBC27cpp,'3',rT179start_position(C));
  1053. _tt=XrT58run_type(XrT68result_type((C)->_target));
  1054. /*IF*/if (((XrT58is_expanded(_tt))||(XrT68is_current((C)->_target)))||(XrT68is_manifest_string((C)->_target))) {
  1055. rT40push_direct((T40*)oRBC27cpp,(C)->_run_feature,(C)->_target,(C)->_arguments);
  1056. XrT261mapping_c((C)->_run_feature);
  1057. rT40pop((T40*)oRBC27cpp);
  1058. }
  1059. else {
  1060. _r=((T260*)XrT58run_class(_tt))->_running;
  1061. /*IF*/if (!(_r)) {
  1062. rT40push_void((T40*)oRBC27cpp,(C)->_run_feature,(C)->_target,(C)->_arguments);
  1063. XrT261mapping_c((C)->_run_feature);
  1064. rT40pop((T40*)oRBC27cpp);
  1065. }
  1066.  else if ((rT263count((T263*)_r))==(1)) {
  1067. _dyn_rf=rT179dynamic(rT263first((T263*)_r),(C)->_run_feature);
  1068. rT40push_check((T40*)oRBC27cpp,_dyn_rf,(C)->_target,(C)->_arguments);
  1069. XrT261mapping_c(_dyn_rf);
  1070. rT40pop((T40*)oRBC27cpp);
  1071. }
  1072. else {
  1073. rT40use_switch((T40*)oRBC27cpp,(C)->_run_feature,_r,(C)->_target,(C)->_arguments);
  1074. }
  1075. /*FI*/}
  1076. /*FI*/rT40rs_pop_position((T40*)oRBC27cpp);
  1077. }
  1078. T0 * rT179dynamic(/*C*/T0 * a1,T0 * a2){
  1079. T0 * R=NULL;
  1080. T0 * _static=NULL;
  1081. T0 * _sta_name=NULL;
  1082. T0 * _dyn_name=NULL;
  1083. _static=XrT261current_type(a2);
  1084. _sta_name=XrT261name(a2);
  1085. _dyn_name=rT50name_of((T50*)rT260base_class((T260*)a1),XrT58base_class(_static),_sta_name);
  1086. R=rT260get_feature((T260*)a1,_dyn_name);
  1087. return R;
  1088. }
  1089. void rT179copy(T179 *C,T0 * a1){
  1090. /*IF*//*AF*//*AE*/
  1091. memcpy(C,a1,s[C->id]);
  1092. /*FI*/}
  1093. void rT179make(T179 *C,T0 * a1,T0 * a2,T0 * a3){
  1094. C->_target=a1;
  1095. C->_procedure_name=a2;
  1096. C->_arguments=a3;
  1097. }
  1098. T0 * rT178current_type(T178 *C){
  1099. T0 * R=NULL;
  1100. /*IF*/if (((int)(C)->_run_compound)) {
  1101. R=((T140*)(C)->_run_compound)->_current_type;
  1102. }
  1103. /*FI*/return R;
  1104. }
  1105. void rT178to_runnable_0(T178 *C,T0 * a1){
  1106. T0 * _tt=NULL;
  1107. T0 * _t=NULL;
  1108. C->_run_compound=a1;
  1109. _t=XrT68to_runnable((C)->_target,rT178current_type(C));
  1110. /*IF*/if (!(_t)) {
  1111. rT178error(XrT68start_position((C)->_target),(T0 *)ms1218);
  1112. }
  1113. else {
  1114. C->_target=_t;
  1115. _tt=XrT58run_type(XrT68result_type((C)->_target));
  1116. C->_run_feature=rT260get_rf((T260*)XrT58run_class(_tt),(C)->_target,(C)->_procedure_name);
  1117. }
  1118. /*FI*//*IF*/if (((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)==(0))&&(((int)XrT261result_type((C)->_run_feature)))) {
  1119. /*UT*/(T45*)oRBC27eh;
  1120. rT45add_position(XrT261start_position((C)->_run_feature));
  1121. /*UT*/(T45*)oRBC27eh;
  1122. rT45append((T0 *)ms1219);
  1123. rT178error(XrT67start_position((C)->_procedure_name),(T0 *)ms1220);
  1124. }
  1125. /*FI*//*IF*/if ((((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)==(0))&&(!(XrT68is_current((C)->_target))))&&(!(XrT261is_exported_in((C)->_run_feature,XrT68written_in((C)->_target))))) {
  1126. /*UT*/(T45*)oRBC27eh;
  1127. rT45add_position(XrT261start_position((C)->_run_feature));
  1128. /*UT*/(T45*)oRBC27eh;
  1129. rT45append((T0 *)ms1221);
  1130. /*UT*/(T45*)oRBC27eh;
  1131. rT45append(XrT67to_string((C)->_procedure_name));
  1132. rT178error(XrT67start_position((C)->_procedure_name),(T0 *)ms1222);
  1133. }
  1134. /*FI*/}
  1135. T0 * rT178to_runnable(T178 *C,T0 * a1){
  1136. T0 * R=NULL;
  1137. /*IF*/if (!((C)->_run_compound)) {
  1138. rT178to_runnable_0(C,a1);
  1139. /*IF*/if (((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)==(0))&&((XrT261arg_count((C)->_run_feature))>(0))) {
  1140. /*UT*/(T45*)oRBC27eh;
  1141. rT45add_position(XrT67start_position((C)->_procedure_name));
  1142. rT178error(XrT261start_position((C)->_run_feature),(T0 *)ms1223);
  1143. }
  1144. /*FI*//*IF*/if ((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)==(0)) {
  1145. R=(T0 *)C;
  1146. }
  1147. /*FI*/}
  1148. else {
  1149. {T178 *n=((T178*)new(178));
  1150. rT178make(n,(C)->_target,(C)->_procedure_name);
  1151. R=(T0 *)n;}
  1152. R=rT178to_runnable((T178*)R,a1);
  1153. }
  1154. /*FI*/return R;
  1155. }
  1156. void rT178error(/*C*/T0 * a1,T0* a2){
  1157. /*UT*/(T45*)oRBC27eh;
  1158. rT45add_position(a1);
  1159. rT45error((T45*)oRBC27eh,a2);
  1160. }
  1161. T0 * rT178add_comment(T178 *C,T0 * a1){
  1162. T0 * R=NULL;
  1163. /*IF*/if ((!(a1))||((rT59count((T59*)a1))==(0))) {
  1164. R=(T0 *)C;
  1165. }
  1166. /*AF*/else {
  1167. {T216 *n=((T216*)new(216));
  1168. rT216make(n,(T0 *)C,a1);
  1169. R=(T0 *)n;}}
  1170. /*FI*/return R;
  1171. }
  1172. T0 * rT178start_position(T178 *C){
  1173. T0 * R=NULL;
  1174. R=XrT68start_position((C)->_target);
  1175. /*IF*/if (!(R)) {
  1176. R=XrT67start_position((C)->_procedure_name);
  1177. }
  1178. /*FI*/return R;
  1179. }
  1180. int rT178use_current(T178 *C){
  1181. int R=0;
  1182. /*IF*//*AF*//*AE*/
  1183. /*FI*//*IF*/if (R) {
  1184. }
  1185.  else if (XrT68is_current((C)->_target)) {
  1186. R=XrT261use_current((C)->_run_feature);
  1187. }
  1188. else {
  1189. R=XrT68use_current((C)->_target);
  1190. }
  1191. /*FI*/return R;
  1192. }
  1193. void rT178compile_to_c(T178 *C){
  1194. T0 * _dyn_rf=NULL;
  1195. T0 * _tt=NULL;
  1196. T0* _r=NULL;
  1197. rT40rs_push_position((T40*)oRBC27cpp,'3',rT178start_position(C));
  1198. _tt=XrT58run_type(XrT68result_type((C)->_target));
  1199. /*IF*/if (((XrT58is_expanded(_tt))||(XrT68is_current((C)->_target)))||(XrT68is_manifest_string((C)->_target))) {
  1200. rT40push_direct((T40*)oRBC27cpp,(C)->_run_feature,(C)->_target,/*(IRF4*/NULL/*)*/);
  1201. XrT261mapping_c((C)->_run_feature);
  1202. rT40pop((T40*)oRBC27cpp);
  1203. }
  1204. else {
  1205. _r=((T260*)XrT58run_class(_tt))->_running;
  1206. /*IF*/if (!(_r)) {
  1207. rT40push_void((T40*)oRBC27cpp,(C)->_run_feature,(C)->_target,/*(IRF4*/NULL/*)*/);
  1208. XrT261mapping_c((C)->_run_feature);
  1209. rT40pop((T40*)oRBC27cpp);
  1210. }
  1211.  else if ((rT263count((T263*)_r))==(1)) {
  1212. _dyn_rf=rT178dynamic(rT263first((T263*)_r),(C)->_run_feature);
  1213. rT40push_check((T40*)oRBC27cpp,_dyn_rf,(C)->_target,/*(IRF4*/NULL/*)*/);
  1214. XrT261mapping_c(_dyn_rf);
  1215. rT40pop((T40*)oRBC27cpp);
  1216. }
  1217. else {
  1218. rT40use_switch((T40*)oRBC27cpp,(C)->_run_feature,_r,(C)->_target,/*(IRF4*/NULL/*)*/);
  1219. }
  1220. /*FI*/}
  1221. /*FI*/rT40rs_pop_position((T40*)oRBC27cpp);
  1222. }
  1223. T0 * rT178dynamic(/*C*/T0 * a1,T0 * a2){
  1224. T0 * R=NULL;
  1225. T0 * _static=NULL;
  1226. T0 * _sta_name=NULL;
  1227. T0 * _dyn_name=NULL;
  1228. _static=XrT261current_type(a2);
  1229. _sta_name=XrT261name(a2);
  1230. _dyn_name=rT50name_of((T50*)rT260base_class((T260*)a1),XrT58base_class(_static),_sta_name);
  1231. R=rT260get_feature((T260*)a1,_dyn_name);
  1232. return R;
  1233. }
  1234. void rT178copy(T178 *C,T0 * a1){
  1235. /*IF*//*AF*//*AE*/
  1236. memcpy(C,a1,s[C->id]);
  1237. /*FI*/}
  1238. void rT178make(T178 *C,T0 * a1,T0 * a2){
  1239. C->_target=a1;
  1240. C->_procedure_name=a2;
  1241. }
  1242. void rT136warning(/*C*/T0 * a1,T0* a2){
  1243. /*UT*/(T45*)oRBC27eh;
  1244. rT45add_position(a1);
  1245. rT45warning((T45*)oRBC27eh,a2);
  1246. }
  1247. T0 * rT136to_procedure_or_function(T136 *C){
  1248. T0 * R=NULL;
  1249. /*IF*/if (!((C)->_type)) {
  1250. {T251 *n=((T251*)new(251));
  1251. rT251make(n,rT136n(C),(C)->_arguments,(C)->_obsolete_mark,(C)->_header_comment,(C)->_require_assertion,(C)->_local_vars,(C)->_routine_body);
  1252. R=(T0 *)n;}}
  1253. else {
  1254. {T252 *n=((T252*)new(252));
  1255. rT252make(n,rT136n(C),(C)->_arguments,(C)->_type,(C)->_obsolete_mark,(C)->_header_comment,(C)->_require_assertion,(C)->_local_vars,(C)->_routine_body);
  1256. R=(T0 *)n;}}
  1257. /*FI*/return R;
  1258. }
  1259. void rT136error(/*C*/T0 * a1,T0* a2){
  1260. /*UT*/(T45*)oRBC27eh;
  1261. rT45add_position(a1);
  1262. rT45error((T45*)oRBC27eh,a2);
  1263. }
  1264. T0 * rT136to_writable_attribute(T136 *C){
  1265. T0 * R=NULL;
  1266. /*IF*/if (!((C)->_type)) {
  1267. rT136error(XrT67start_position(rT129first((T129*)oRBC136names)),(T0 *)ms405);
  1268. }
  1269.  else if (((int)(C)->_arguments)) {
  1270. rT136error(rT51current_position((T51*)oRBC27eiffel_parser),(T0 *)ms406);
  1271. }
  1272. /*FI*/{T256 *n=((T256*)new(256));
  1273. rT256make(n,rT136n(C),(C)->_type);
  1274. R=(T0 *)n;}
  1275. return R;
  1276. }
  1277. T0 * rT136to_deferred_routine(T136 *C){
  1278. T0 * R=NULL;
  1279. /*IF*/if (!((C)->_type)) {
  1280. {T204 *n=((T204*)new(204));
  1281. rT204make(n,rT136n(C),(C)->_arguments,(C)->_obsolete_mark,(C)->_header_comment,(C)->_require_assertion);
  1282. R=(T0 *)n;}}
  1283. else {
  1284. {T205 *n=((T205*)new(205));
  1285. rT205make(n,rT136n(C),(C)->_arguments,(C)->_type,(C)->_obsolete_mark,(C)->_header_comment,(C)->_require_assertion);
  1286. R=(T0 *)n;}}
  1287. /*FI*/return R;
  1288. }
  1289. T0 * rT136n(T136 *C){
  1290. T0 * R=NULL;
  1291. {T128 *n=((T128*)new(128));
  1292. rT128make(n,rT136clone(C,oRBC136names));
  1293. R=(T0 *)n;}
  1294. return R;
  1295. }
  1296. T0* rT136clone(T136 *C,T0* a1){
  1297. T0* R=NULL;
  1298. /*IF*/if (((int)a1)) {
  1299. R=(T0 *)new(a1->id);
  1300. AF_1
  1301. XrT28copy(R,a1);
  1302. AF_0
  1303. }
  1304. /*FI*/return R;
  1305. }
  1306. T0*oRBC136names;
  1307. T0 * rT136to_cst_att_integer(T136 *C,T0 * a1){
  1308. T0 * R=NULL;
  1309. /*IF*/if (((int)(C)->_type)) {
  1310. /*IF*/if (XrT58is_integer((C)->_type)) {
  1311. {T155 *n=((T155*)new(155));
  1312. rT155make(n,rT136n(C),(C)->_type,a1);
  1313. R=(T0 *)n;}}
  1314.  else if (XrT58is_real((C)->_type)) {
  1315. {T153 *n=((T153*)new(153));
  1316. rT153make(n,rT136n(C),(C)->_type,rT80to_real_constant((T80*)a1));
  1317. R=(T0 *)n;}}
  1318.  else if (XrT58is_double((C)->_type)) {
  1319. {T154 *n=((T154*)new(154));
  1320. rT154make(n,rT136n(C),(C)->_type,rT80to_real_constant((T80*)a1));
  1321. R=(T0 *)n;}}
  1322. else {
  1323. rT136error(XrT67start_position(rT129first((T129*)oRBC136names)),(T0 *)ms277);
  1324. }
  1325. /*FI*/}
  1326. else {
  1327. rT136error(XrT67start_position(rT129first((T129*)oRBC136names)),(T0 *)ms278);
  1328. }
  1329. /*FI*/return R;
  1330. }
  1331. T0 * rT136to_cst_att_real(T136 *C,T0 * a1){
  1332. T0 * R=NULL;
  1333. /*IF*/if (((int)(C)->_type)) {
  1334. /*IF*/if (XrT58is_real((C)->_type)) {
  1335. {T153 *n=((T153*)new(153));
  1336. rT153make(n,rT136n(C),(C)->_type,a1);
  1337. R=(T0 *)n;}}
  1338.  else if (XrT58is_double((C)->_type)) {
  1339. {T154 *n=((T154*)new(154));
  1340. rT154make(n,rT136n(C),(C)->_type,a1);
  1341. R=(T0 *)n;}}
  1342.  else if (XrT58is_integer((C)->_type)) {
  1343. rT136warning(((T79*)a1)->_start_position,(T0 *)ms272);
  1344. {T155 *n=((T155*)new(155));
  1345. rT155make(n,rT136n(C),(C)->_type,rT79to_integer_constant((T79*)a1));
  1346. R=(T0 *)n;}}
  1347. else {
  1348. rT136error(XrT67start_position(rT129first((T129*)oRBC136names)),(T0 *)ms274);
  1349. }
  1350. /*FI*/}
  1351. else {
  1352. rT136error(XrT67start_position(rT129first((T129*)oRBC136names)),(T0 *)ms275);
  1353. }
  1354. /*FI*/return R;
  1355. }
  1356. T0 * rT136to_cst_att_bit(T136 *C,T0 * a1){
  1357. T0 * R=NULL;
  1358. /*IF*/if ((((int)(C)->_type))&&(XrT58is_bit((C)->_type))) {
  1359. {T152 *n=((T152*)new(152));
  1360. rT152make(n,rT136n(C),(C)->_type,a1);
  1361. R=(T0 *)n;}
  1362. }
  1363. else {
  1364. rT136error(XrT67start_position(rT129first((T129*)oRBC136names)),(T0 *)ms271);
  1365. }
  1366. /*FI*/return R;
  1367. }
  1368. T0 * rT136to_cst_att_string(T136 *C,T0 * a1){
  1369. T0 * R=NULL;
  1370. /*IF*/if ((((int)(C)->_type))&&(XrT58is_string((C)->_type))) {
  1371. {T150 *n=((T150*)new(150));
  1372. rT150make(n,rT136n(C),(C)->_type,a1);
  1373. R=(T0 *)n;}
  1374. }
  1375. else {
  1376. rT136error(XrT67start_position(rT129first((T129*)oRBC136names)),(T0 *)ms270);
  1377. }
  1378. /*FI*/return R;
  1379. }
  1380. T0 * rT136to_cst_att_character(T136 *C,T0 * a1){
  1381. T0 * R=NULL;
  1382. /*IF*/if ((((int)(C)->_type))&&(XrT58is_character((C)->_type))) {
  1383. {T149 *n=((T149*)new(149));
  1384. rT149make(n,rT136n(C),(C)->_type,a1);
  1385. R=(T0 *)n;}
  1386. }
  1387. else {
  1388. rT136error(XrT67start_position(rT129first((T129*)oRBC136names)),(T0 *)ms269);
  1389. }
  1390. /*FI*/return R;
  1391. }
  1392. T0 * rT136to_cst_att_boolean(T136 *C,T0 * a1){
  1393. T0 * R=NULL;
  1394. /*IF*/if ((((int)(C)->_type))&&(XrT58is_boolean((C)->_type))) {
  1395. {T148 *n=((T148*)new(148));
  1396. rT148make(n,rT136n(C),(C)->_type,a1);
  1397. R=(T0 *)n;}
  1398. }
  1399. else {
  1400. rT136error(XrT67start_position(rT129first((T129*)oRBC136names)),(T0 *)ms268);
  1401. }
  1402. /*FI*/return R;
  1403. }
  1404. T0 * rT136to_cst_att_unique(T136 *C){
  1405. T0 * R=NULL;
  1406. T0 * _sp=NULL;
  1407. /*IF*/if (!((C)->_type)) {
  1408. _sp=XrT67start_position(rT129first((T129*)oRBC136names));
  1409. rT136error(_sp,(T0 *)ms266);
  1410. }
  1411. /*FI*//*IF*/if (!(XrT58is_integer((C)->_type))) {
  1412. rT136error(XrT58start_position((C)->_type),(T0 *)ms267);
  1413. }
  1414. /*FI*/{T144 *n=((T144*)new(144));
  1415. rT144make(n,rT136n(C),(C)->_type);
  1416. R=(T0 *)n;}
  1417. return R;
  1418. }
  1419. void rT136copy(T136 *C,T0 * a1){
  1420. /*IF*//*AF*//*AE*/
  1421. memcpy(C,a1,s[C->id]);
  1422. /*FI*/}
  1423. void rT136add_synonym(/*C*/T0 * a1){
  1424. rT129add_last((T129*)oRBC136names,a1);
  1425. }
  1426. void rT136set_require(T136 *C,T0 * a1,T0 * a2,T0* a3){
  1427. /*IF*/if ((((int)a2))||(((int)a3))) {
  1428. {T137 *n=((T137*)new(137));
  1429. rT137make(n,a1,a2,a3);
  1430. C->_require_assertion=(T0 *)n;}
  1431. }
  1432. /*FI*/}
  1433. void rT136set_require_else(T136 *C,T0 * a1,T0 * a2,T0* a3){
  1434. /*IF*/if ((((int)a2))||(((int)a3))) {
  1435. {T137 *n=((T137*)new(137));
  1436. rT137make(n,a1,a2,a3);
  1437. C->_require_assertion=(T0 *)n;}
  1438. /*(IRF3*/(((T137*)(C)->_require_assertion)->_is_require_else)=(1);
  1439. /*)*/}
  1440. /*FI*/}
  1441. void rT136initialize(T136 *C){
  1442. rT129clear((T129*)oRBC136names);
  1443. C->_arguments=NULL;
  1444. C->_type=NULL;
  1445. C->_header_comment=NULL;
  1446. C->_obsolete_mark=NULL;
  1447. C->_require_assertion=NULL;
  1448. C->_local_vars=NULL;
  1449. C->_routine_body=NULL;
  1450. }
  1451. T0 * rT136to_once_routine(T136 *C){
  1452. T0 * R=NULL;
  1453. /*IF*/if (!((C)->_type)) {
  1454. {T254 *n=((T254*)new(254));
  1455. rT254make(n,rT136n(C),(C)->_arguments,(C)->_obsolete_mark,(C)->_header_comment,(C)->_require_assertion,(C)->_local_vars,(C)->_routine_body);
  1456. R=(T0 *)n;}}
  1457. else {
  1458. {T255 *n=((T255*)new(255));
  1459. rT255make(n,rT136n(C),(C)->_arguments,(C)->_type,(C)->_obsolete_mark,(C)->_header_comment,(C)->_require_assertion,(C)->_local_vars,(C)->_routine_body);
  1460. R=(T0 *)n;}}
  1461. /*FI*/return R;
  1462. }
  1463. T0 * rT136to_external_routine(T136 *C,T0 * a1,T0* a2){
  1464. T0 * R=NULL;
  1465. /*IF*/if (!((C)->_type)) {
  1466. {T211 *n=((T211*)new(211));
  1467. rT211make(n,rT136n(C),(C)->_arguments,(C)->_obsolete_mark,(C)->_header_comment,(C)->_require_assertion,a1,a2);
  1468. R=(T0 *)n;}}
  1469. else {
  1470. {T212 *n=((T212*)new(212));
  1471. rT212make(n,rT136n(C),(C)->_arguments,(C)->_type,(C)->_obsolete_mark,(C)->_header_comment,(C)->_require_assertion,a1,a2);
  1472. R=(T0 *)n;}}
  1473. /*FI*/return R;
  1474. }
  1475. T0* rT260runnable(T260 *C,T0* a1,T0 * a2,T0 * a3){
  1476. T0* R=NULL;
  1477. T0 * _a=NULL;
  1478. int _i=0;
  1479. /*IF*/if (!(rT158empty((T158*)a1))) {
  1480. R=rT260clone(C,a1);
  1481. _i=1;
  1482. while (!((_i)>(((T158*)R)->_upper))) {
  1483. rT52push((T52*)oRBC27small_eiffel,a3);
  1484. _a=rT64to_runnable((T64*)rT158item((T158*)R,_i),a2);
  1485. /*IF*/if (!(_a)) {
  1486. rT260error(rT64start_position((T64*)rT158item((T158*)R,_i)),(T0 *)ms477);
  1487. }
  1488. else {
  1489. rT158put((T158*)R,_a,_i);
  1490. }
  1491. /*FI*/rT52pop((T52*)oRBC27small_eiffel);
  1492. _i=(_i)+(1);
  1493. }
  1494. }
  1495. /*FI*/return R;
  1496. }
  1497. T0 * rT260get_feature(T260 *C,T0 * a1){
  1498. T0 * R=NULL;
  1499. T0* _fn_key=NULL;
  1500. T0 * _f=NULL;
  1501. _fn_key=XrT67to_key(a1);
  1502. /*IF*/if (rT264has((T264*)(C)->_feature_dictionary,_fn_key)) {
  1503. R=rT264at((T264*)(C)->_feature_dictionary,_fn_key);
  1504. }
  1505. else {
  1506. _f=rT50look_up_for((T50*)rT260base_class(C),(T0 *)C,a1);
  1507. /*IF*/if (!(_f)) {
  1508. /*UT*/(T45*)oRBC27eh;
  1509. rT45append((T0 *)ms517);
  1510. /*UT*/(T45*)oRBC27eh;
  1511. rT45append(XrT67to_string(a1));
  1512. /*UT*/(T45*)oRBC27eh;
  1513. rT45append((T0 *)ms518);
  1514. /*UT*/(T45*)oRBC27eh;
  1515. rT45append(((T48*)((T50*)rT260base_class(C))->_base_class_name)->_to_string);
  1516. rT260error(XrT67start_position(a1),(T0 *)ms38);
  1517. }
  1518. else {
  1519. R=XrT62to_run_feature(_f,(C)->_current_type,a1);
  1520. /*IF*/if (((int)R)) {
  1521. rT260store_feature(C,R);
  1522. }
  1523. /*FI*/}
  1524. /*FI*/}
  1525. /*FI*/return R;
  1526. }
  1527. T0 * rT260get_feature_with(T260 *C,T0* a1){
  1528. T0 * R=NULL;
  1529. T0 * _fn=NULL;
  1530. /*IF*/if (rT264has((T264*)(C)->_feature_dictionary,a1)) {
  1531. R=rT264at((T264*)(C)->_feature_dictionary,a1);
  1532. }
  1533. else {
  1534. {T67 *n=((T67*)new(67));
  1535. rT67make(n,a1,NULL);
  1536. _fn=(T0 *)n;}
  1537. R=rT260get_feature(C,_fn);
  1538. }
  1539. /*FI*/return R;
  1540. }
  1541. T0* rT260writable_attributes(T260 *C){
  1542. T0* R=NULL;
  1543. int _i=0;
  1544. T0 * _rf=NULL;
  1545. /*IF*/if (!((C)->_writable_attributes_mem)) {
  1546. _i=1;
  1547. while (!((_i)>(((T264*)(C)->_feature_dictionary)->_count))) {
  1548. _rf=rT264item((T264*)(C)->_feature_dictionary,_i);
  1549. /*IF*/if (XrT261is_writable(_rf)) {
  1550. /*IF*/if (!((C)->_writable_attributes_mem)) {
  1551. C->_writable_attributes_mem=ma(265,0,1,_rf);
  1552. }
  1553. else {
  1554. XrT265add_last((C)->_writable_attributes_mem,_rf);
  1555. }
  1556. /*FI*/}
  1557. /*FI*/_i=(_i)+(1);
  1558. }
  1559. }
  1560. /*FI*/R=(C)->_writable_attributes_mem;
  1561. return R;
  1562. }
  1563. void rT260falling_down(T260 *C){
  1564. int _i=0;
  1565. T0 * _rf=NULL;
  1566. _i=1;
  1567. while (!((_i)>(((T264*)(C)->_feature_dictionary)->_count))) {
  1568. _rf=rT264item((T264*)(C)->_feature_dictionary,_i);
  1569. XrT261fall_down(_rf);
  1570. _i=(_i)+(1);
  1571. }
  1572. }
  1573. void rT260fatal_error(/*C*/T0* a1){
  1574. rT45fatal_error((T45*)oRBC27eh,a1);
  1575. }
  1576. void rT260error(/*C*/T0 * a1,T0* a2){
  1577. /*UT*/(T45*)oRBC27eh;
  1578. rT45add_position(a1);
  1579. rT45error((T45*)oRBC27eh,a2);
  1580. }
  1581. void rT260set_at_run_time(T260 *C){
  1582. int _i=0;
  1583. T0 * _rc=NULL;
  1584. T0 * _rcd=NULL;
  1585. /*IF*/if (!((C)->_at_run_time)) {
  1586. C->_at_run_time=1;
  1587. rT260add_running(C,(T0 *)C);
  1588. /*(IRF3*/(((T50*)rT260base_class(C))->_at_run_time)=(1);
  1589. /*)*/rT52incr_magic_count((T52*)oRBC27small_eiffel);
  1590. /*IF*/if (XrT58is_reference((C)->_current_type)) {
  1591. _rcd=oRBC52run_class_dictionary;
  1592. _i=1;
  1593. while (!((_i)>(((T262*)_rcd)->_count))) {
  1594. _rc=rT262item((T262*)_rcd,_i);
  1595. /*IF*/if (rT260is_a(C,_rc)) {
  1596. rT260add_running((T260*)_rc,(T0 *)C);
  1597. }
  1598. /*FI*/_i=(_i)+(1);
  1599. }
  1600. }
  1601. /*FI*/}
  1602. /*FI*/}
  1603. void rT260store_feature(T260 *C,T0 * a1){
  1604. T0 * _rf2=NULL;
  1605. T0* _rf_key=NULL;
  1606. _rf_key=XrT67to_key(XrT261name(a1));
  1607. /*IF*/if (rT264has((T264*)(C)->_feature_dictionary,_rf_key)) {
  1608. _rf2=rT264at((T264*)(C)->_feature_dictionary,_rf_key);
  1609. /*IF*/if (((T0 *)a1)!=((T0 *)_rf2)) {
  1610. /*UT*/(T45*)oRBC27eh;
  1611. rT45add_position(XrT261start_position(a1));
  1612. /*UT*/(T45*)oRBC27eh;
  1613. rT45add_position(XrT261start_position(_rf2));
  1614. rT260fatal_error((T0 *)ms519);
  1615. }
  1616. /*FI*/}
  1617. else {
  1618. rT264put((T264*)(C)->_feature_dictionary,a1,_rf_key);
  1619. rT52incr_magic_count((T52*)oRBC27small_eiffel);
  1620. }
  1621. /*FI*/}
  1622. void rT260collect_invariant(/*C*/T0 * a1){
  1623. rT259add_into((T259*)a1,oRBC260collector);
  1624. }
  1625. T0*oRBC260collector;
  1626. T0 * rT260get_rf(T260 *C,T0 * a1,T0 * a2){
  1627. T0 * R=NULL;
  1628. T0 * _sub_fn=NULL;
  1629. T0 * _wbc=NULL;
  1630. T0 * _ctbc=NULL;
  1631. T0 * _wp=NULL;
  1632. _ctbc=XrT58base_class((C)->_current_type);
  1633. _wp=XrT68start_position(a1);
  1634. /*IF*/if (!(_wp)) {
  1635. _wp=XrT67start_position(a2);
  1636. }
  1637. /*FI*/_wbc=rT46base_class((T46*)_wp);
  1638. /*IF*/if (XrT68is_current(a1)) {
  1639. _sub_fn=rT50name_of((T50*)_ctbc,_wbc,a2);
  1640. }
  1641. else {
  1642. _sub_fn=a2;
  1643. }
  1644. /*FI*/R=rT260get_feature(C,_sub_fn);
  1645. /*IF*/if (!(R)) {
  1646. /*UT*/(T45*)oRBC27eh;
  1647. rT45add_position(XrT67start_position(a2));
  1648. /*UT*/(T45*)oRBC27eh;
  1649. rT45append((T0 *)ms1120);
  1650. /*UT*/(T45*)oRBC27eh;
  1651. rT45append(XrT67to_string(a2));
  1652. /*UT*/(T45*)oRBC27eh;
  1653. rT45append((T0 *)ms1121);
  1654. /*UT*/(T45*)oRBC27eh;
  1655. rT45add_type((C)->_current_type,(T0 *)ms38);
  1656. rT45print_as_fatal_error((T45*)oRBC27eh);
  1657. }
  1658. /*FI*/XrT261add_clients(R,(T0 *)C);
  1659. /*IF*/if ((((/*(IRF4*/((T45*)oRBC27eh)->_nb_errors/*)*/)==(0))&&(!(XrT68is_current(a1))))&&(!(XrT261is_exported_in(R,((T50*)_wbc)->_base_class_name)))) {
  1660. /*UT*/(T45*)oRBC27eh;
  1661. rT45add_position(XrT261start_position(R));
  1662. /*UT*/(T45*)oRBC27eh;
  1663. rT45append((T0 *)ms1129);
  1664. /*UT*/(T45*)oRBC27eh;
  1665. rT45append(XrT67to_string(a2));
  1666. rT260error(_wp,(T0 *)ms1130);
  1667. }
  1668. /*FI*/return R;
  1669. }
  1670. T0* rT260clone(T260 *C,T0* a1){
  1671. T0* R=NULL;
  1672. /*IF*/if (((int)a1)) {
  1673. R=(T0 *)new(a1->id);
  1674. AF_1
  1675. XrT28copy(R,a1);
  1676. AF_0
  1677. }
  1678. /*FI*/return R;
  1679. }
  1680. T0 * rT260at(T260 *C,T0 * a1){
  1681. T0 * R=NULL;
  1682. T0* _to_key=NULL;
  1683. _to_key=XrT67to_key(a1);
  1684. /*IF*/if (rT264has((T264*)(C)->_feature_dictionary,_to_key)) {
  1685. R=rT264at((T264*)(C)->_feature_dictionary,_to_key);
  1686. }
  1687. /*FI*/return R;
  1688. }
  1689. void rT260compile_to_c(T260 *C){
  1690. int _i=0;
  1691. T0 * _rf=NULL;
  1692. /*IF*/if ((C)->_at_run_time) {
  1693. rT38put_character((T38*)oRBC1std_output,'\11');
  1694. rT38put_string((T38*)oRBC1std_output,XrT58run_time_mark((C)->_current_type));
  1695. rT38put_character((T38*)oRBC1std_output,'\12');
  1696. _i=1;
  1697. while (!((_i)>(((T264*)(C)->_feature_dictionary)->_count))) {
  1698. _rf=rT264item((T264*)(C)->_feature_dictionary,_i);
  1699. /*IF*/if (!(XrT261is_writable(_rf))) {
  1700. XrT261c_define(_rf);
  1701. }
  1702. /*FI*/_i=(_i)+(1);
  1703. }
  1704. /*IF*/if (rT44invariant_check((T44*)oRBC27eiffel_run_control)) {
  1705. /*IF*/if (((int)(C)->_invariant_assertion)) {
  1706. rT259c_define((T259*)(C)->_invariant_assertion);
  1707. }
  1708. /*FI*/}
  1709. /*FI*/}
  1710. /*FI*/}
  1711. T0 * rT260base_class(T260 *C){
  1712. T0 * R=NULL;
  1713. R=XrT58base_class((C)->_current_type);
  1714. return R;
  1715. }
  1716. void rT260add_running(T260 *C,T0 * a1){
  1717. /*IF*/if (!((C)->_running)) {
  1718. C->_running=ma(263,0,1,a1);
  1719. }
  1720. else {
  1721. /*IF*/if (!(rT263fast_has((T263*)(C)->_running,a1))) {
  1722. rT263add_last((T263*)(C)->_running,a1);
  1723. }
  1724. /*FI*/}
  1725. /*FI*/}
  1726. void rT260copy(T260 *C,T0 * a1){
  1727. /*IF*//*AF*//*AE*/
  1728. memcpy(C,a1,s[C->id]);
  1729. /*FI*/}
  1730. int rT260is_a(T260 *C,T0 * a1){
  1731. int R=0;
  1732. T0 * _t2=NULL;
  1733. T0 * _t1=NULL;
  1734. /*IF*/if (((T0 *)a1)==((T0 *)C)) {
  1735. R=1;
  1736. }
  1737. else {
  1738. _t1=(C)->_current_type;
  1739. _t2=((T260*)a1)->_current_type;
  1740. /*IF*/if ((XrT58is_integer(_t1))&&(XrT58is_real(_t2))) {
  1741. R=0;
  1742. }
  1743. else {
  1744. R=XrT58is_a(_t1,_t2);
  1745. /*IF*/if (!(R)) {
  1746. /*(IRF3*//*UT*/(T45*)oRBC27eh;
  1747. /*(IRF3*/(((T7*)oRBC45explanation)->_count)=(0);
  1748. /*)*/rT47clear((T47*)rT45positions());
  1749. /*)*/}
  1750. /*FI*/}
  1751. /*FI*/}
  1752. /*FI*/return R;
  1753. }
  1754. void rT260make(T260 *C,T0 * a1){
  1755. int _i=0;
  1756. T0* _r=NULL;
  1757. T0 * _rc=NULL;
  1758. T0 * _rcd=NULL;
  1759. T0* _run_string=NULL;
  1760. C->_current_type=a1;
  1761. /*IF*/if (XrT58fast_mapping_c(a1)) {
  1762. C->_id=((T50*)XrT58base_class(a1))->_id;
  1763. }
  1764.  else if (XrT58is_reference(a1)) {
  1765. /*IF*/if (XrT58is_generic(a1)) {
  1766. C->_id=rT52next_id((T52*)oRBC27small_eiffel);
  1767. }
  1768. else {
  1769. C->_id=((T50*)XrT58base_class(a1))->_id;
  1770. }
  1771. /*FI*/}
  1772. else {
  1773. /*IF*/if (((T50*)XrT58base_class(a1))->_is_expanded) {
  1774. C->_id=((T50*)XrT58base_class(a1))->_id;
  1775. }
  1776. else {
  1777. C->_id=rT52next_id((T52*)oRBC27small_eiffel);
  1778. }
  1779. /*FI*/}
  1780. /*FI*/_run_string=XrT58run_time_mark(a1);
  1781. rT262put((T262*)oRBC52run_class_dictionary,(T0 *)C,_run_string);
  1782. {T264 *n=((T264*)new(264));
  1783. rT264make(n);
  1784. C->_feature_dictionary=(T0 *)n;}
  1785. rT52incr_magic_count((T52*)oRBC27small_eiffel);
  1786. /*IF*/if (XrT58is_expanded(a1)) {
  1787. rT260set_at_run_time(C);
  1788. }
  1789. else {
  1790. _rcd=oRBC52run_class_dictionary;
  1791. _i=1;
  1792. while (!((_i)>(((T262*)_rcd)->_count))) {
  1793. _rc=rT262item((T262*)_rcd,_i);
  1794. /*IF*/if (((((T260*)_rc)->_at_run_time)&&(XrT58is_reference(((T260*)_rc)->_current_type)))&&(rT260is_a((T260*)_rc,(T0 *)C))) {
  1795. rT260add_running(C,_rc);
  1796. }
  1797. /*FI*/_i=(_i)+(1);
  1798. }
  1799. }
  1800. /*FI*//*IF*/if (rT44invariant_check((T44*)oRBC27eiffel_run_control)) {
  1801. rT158clear((T158*)oRBC260collector);
  1802. rT50collect_invariant((T50*)rT260base_class(C),(T0 *)C);
  1803. _r=rT260runnable(C,oRBC260collector,(C)->_current_type,NULL);
  1804. /*IF*/if (((int)_r)) {
  1805. {T259 *n=((T259*)new(259));
  1806. rT259from_runnable(n,_r);
  1807. C->_invariant_assertion=(T0 *)n;}
  1808. }
  1809. /*FI*/}
  1810. /*FI*/}
  1811. T0 * rT239to_runnable(T239 *C,T0 * a1){
  1812. T0 * R=NULL;
  1813. /*IF*/if (!(XrT68current_type((C)->_expression))) {
  1814. C->_expression=XrT68to_runnable((C)->_expression,a1);
  1815. R=(T0 *)C;
  1816. }
  1817. else {
  1818. R=rT239clone(C,(T0 *)C);
  1819. /*(IRF3*/(((T239*)R)->_expression)=(XrT68to_runnable((C)->_expression,a1));
  1820. /*)*/}
  1821. /*FI*/return R;
  1822. }
  1823. int rT239use_current(T239 *C){
  1824. int R=0;
  1825. R=XrT68use_current((C)->_expression);
  1826. return R;
  1827. }
  1828. T0* rT239clone(T239 *C,T0* a1){
  1829. T0* R=NULL;
  1830. /*IF*/if (((int)a1)) {
  1831. R=(T0 *)new(a1->id);
  1832. AF_1
  1833. XrT28copy(R,a1);
  1834. AF_0
  1835. }
  1836. /*FI*/return R;
  1837. }
  1838. void rT239copy(T239 *C,T0 * a1){
  1839. /*IF*//*AF*//*AE*/
  1840. memcpy(C,a1,s[C->id]);
  1841. /*FI*/}
  1842.